//public class Test {
//    public static void main(String[] args) {
//        System.out.println(10);//10就是一个字面常量
//        //什么叫变量呢？
//        int a=10;
//        //变量是指在程序内部中可以进行修改的量
//        a=9;
//        a=8;
//        System.out.println(a);//这个时候a就是变量，此时此刻a在main函数内部，所以a是局部变量
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        final int a = 10;
//        //在c语言中我们学到了被coust修饰，java里面有没有呢？
//        //答案：有！！！但是不一样
//        //被final修饰的变量 叫做常量，一旦被final修饰过后就不能再修改了（一般被final修饰后变量名一般都会大写，但不是硬性要求）
//        //a=9; err
//        //a=8; err
//        System.out.println(a);
//    }
//}

//数据类型
//在java中有两大数据类型
//一、基本数据类型
//1.整型 -----byte(1字节)、short(2字节)、int(4字节)、long(8字节)
//2.浮点 -----float double
//3.字符 -----char
//4.布尔 -----boolean
//注意事项:
//*c语言中分别在16位系统和32位系统的内存占用各不一样
//*但是在java中不论在16位系统还是32位系统，int都占用4个字节，long都占用8个字节
//*整型和浮点型都是带有符号的
//*整型默认为int型,浮点型默认为double
//*字符串属于引用类型
//二、引用数据类型
//1.数组
//2.类
//3.接口
//......
//String


//public class Test {
//    public static void main(String[] args) {
//        //怎么定义变量呢？
//        //数据类型+变量名
//        /*
//            int 类型是4个字节
//            最大值：2^31-1
//            最小值：-2^31
//        */
//        int a=10;//定义的同时进行初始化
//        //我们还可以求出它的最大值和最小值
//        System.out.println(Integer.MIN_VALUE);
//        System.out.println(Integer.MAX_VALUE);
//        //Integer
//        //术语：包装类
//        //int的plus版
//        System.out.println(a);
//        //举个例子：如下
//        Integer b=10;
//        System.out.println(b);
//        /*
//        在java当中一个变量没有初始化，那么在使用的时候就会编译报错！！！！
//        int d=2147483648;  解开注释后你会发现编译报错了！！为什么？
//        因为在java中 如果进行变量赋值的时候，字面值超过了可存储的范围，那么编译也会报错！！
//        int d=2147483647-->这个是它的可以执行的最大范围
//        */
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        长整型  8个字节
//        最大值：9223372036854775807
//        最小值：-9223372036854775808
//        */
//        long a=10L;//(在表示长整型时我们赋值的时候可以在值后面加一个大写的L表示长整型，也可以用l小写的，但是可能一下子认为是数字101)
//        System.out.println(a);
//        System.out.println(Long.MAX_VALUE);
//        System.out.println(Long.MIN_VALUE);
//        //注意事项:
//        //1.长整型变量的初始值后加L和l，推荐加L
//        //2.长整型不论在哪个系统下都占8个字节
//        //3.长整型的表示范围在: -2^63 ~ 2^63-1
//        //4.long的包装类型为Long
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        短整型  2个字节
//        最大值: 2^15-1  (32767)
//        最小值: -2^15   (-32768)
//        */
//        short sh = 10;
//        System.out.println(sh);
//        System.out.println(Short.MAX_VALUE);
//        System.out.println(Short.MIN_VALUE);
//        //注意事项:
//        //1.short在任何系统下都占2个字节
//        //2.short的表示范围为: -32768~32767
//        //3.使用时注意不要超过范围(一般使用较少)
//        //4.short的包装类型为Short
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        字节型  1个字节
//        char
//        最大值: 2^7-1 (127)
//        最小值: -2^7  (-128)
//        */
//        byte a='8';
//        System.out.println(a);
//        System.out.println(Byte.MAX_VALUE);
//        System.out.println(Byte.MIN_VALUE);
//        //注意事项:
//        //1.byte在任何系统下都占1个字节
//        //2.byte的范围是: -128~127
//        //3.字节的包装类型是Byte
//    }
//}


//思考:byte、short、int、long都可以定义为整型变量，为什么要给出4中不同类型呢？
//答：类型在存储的空间不同，就好比买衣服时的尺码有s、m、l、xl、xxl……


//public class Test {
//    public static void main(String[] args) {
//        /*
//        浮点型 (双精度) double 8个字节
//        最大值:(7976931348623157E308)
//        最小值:(4.9E-324)
//        */
//        double a=12.5;
//        System.out.println(a);
//        System.out.println(Double.MAX_VALUE);
//        System.out.println(Double.MIN_VALUE);
//        double num=1.1;
//        System.out.println(num*num);//1.2100000000000002
//        //小数是不能精确表示每一位的 它只能说精确表示 小数点后几位
//        //注意事项:
//        //1.double在任何系统下都占8个字节
//        //2.浮点数与整数在内存中的存储方式不同，不能单纯用2^n的形式来计算
//        //3.double的包装类型是Double
//        //4.double 类型的内存布局遵循 IEEE 754标准(和c语言一样)，尝试使用有限的内存空间表示可能无限的小数，势必会存在一定的精度差异，因此浮点数是个近似值，并不是精确值
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        浮点型 (单精度) float 4个字节
//        最大值:(3.4028235E38)
//        最小值:(1.4E-45)
//        */
//        /*float f=12.5; err  解开注释后，编译报错为什么？  因为浮点数默认是double类型8个字节而float是4个字节*/
//        float f=12.5F;//(在赋值的时候在值的后面加上大写/小写的F代表是单精度浮点数)
//        System.out.println(f);
//        System.out.println(Float.MAX_VALUE);
//        System.out.println(Float.MIN_VALUE);
//        //注意事项:
//        //float类型在java中占4个字节，同样遵循IEEE 754标准.由于表示的数据精度范围较小，一般在工程上用到浮点数都优先考虑double，不太推荐使用float.
//        //float的包装类型是Float
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        字符类型 char 是两个字节  它用的是 unicode字符集
//        */
//        char ch1='a';
//        char ch2='周';
//        Character ch3='瑜';
//        System.out.println(ch1);
//        System.out.println(ch2);
//        System.out.println(ch3);
//        //注意事项:
//        //1.java中使用 单引号+单个字母 的形式表示字符字面值
//        //2.计算机中的字符本质上是一个整数.在c语言中使用ASCLL码表中规定的值来表示字符，而java中使用 unicode字符集中的值来表示字符因此一个字符占用2个字节，表示的字符种类更多，包括中文.
//        //char的包装类型为Character
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        /*
//        布尔类型 boolean  没有明确说明大小是多少字节？
//        */
//        boolean b=true;
//        System.out.println(b);
//        //注意事项:
//        //1.bollean类型的变量只有两种取值，true表示真，false表示假
//        //2.java的bollean类型和int不能相互转换，不存在 1表示true,0表示false这样的用法
//        //3.java虚拟机规范中，并没有明确规定bollean占几个字节,也没有专门用来处理bollean的字节码指令,在Oracle公司的虚拟机实现中,bollean占1个字节
//        //4.boolean的包装类型是Boolean
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        int a=10;
//        long b=100L;
//        b=a;
//        /*a=b;*/
//        //为什么b=a可以但是a=b不行？
//        //因为 a的类型是int 是4个字节 b的类型是long 是8个字节  把4个字节放到8个字节中是可以做到的
//        //a=(int)b;  这个编译就可以通过把b的类型强制转换到int
//        //从代码的编译层次来讲 不会报错
//        //但是 它是一颗雷可能在某种情况下会爆炸！！！
//        //如果你把8个字节的long强制转换成（int）放到4个字节中精度会丢失
//        //注意事项:
//        //1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
//        //2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
//        //3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
//        //4. 强制类型转换不一定能成功，不相干的类型不能互相转换
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        int a=10;
//        long b=20;
//        /*
//        int c=a+b;
//        为什么编译器会报错?
//        因为在计算的时候 a的类型是int b的类型是long 把a提升为long --> long类型 和 long类型 进行计算 结果就是long
//        计算出来结果是long再把它放进int里面去是做不到的
//        解决方法: 把 int c 换成 long c
//        */
//        long d=a+b;
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        byte a=10;
//        byte b=20;
//        /*
//        byte c=a+b;
//        这个时候类型都一样了为什么编译器还报错呢?
//        因为计算机的CPU通常是按照4个字节为单位从内存中读取数据,为了硬件上方便实现,比如byte和short这种低于4个字节的类型，会先提升为int,再参与计算
//        byte是小于4个字节的,小于4个字节的数据参加运算的时候 会先提升为int(4个字节) 然后再进行运算
//        解决方法: 把 byte c 换成 int c
//        */
//    }
//}

//public class Test {
//    public static void main(String[] args) {
//        String str="hello";
//        String str2="world";
//        System.out.println(str+str2);//使用加号可以对字符串进行拼接
//        System.out.println(str.length());//求字符串长度
//        //我想输出a==10怎么用字符串的方式输出呢
//        int a=10;
//        System.out.println("a == " + a);
//    }
//}
